package student.aistar.day15.callable;

import java.util.concurrent.*;

/**
 * Callable + Future<T> + 缓冲线程池
 */
public class CallablePoolDemo {
    public static void main(String[] args) {
        //构建一个可缓存的线程对象
        ExecutorService executorService = Executors.newCachedThreadPool();

        //像这个缓冲中提交任务
        //第一个任务 - 负责计算1 ~ 100
        Future<Integer> future1 = executorService.submit(new C2());

        //再向这个缓存池中提交一个任务
        //第二个任务 - 负责计算1~10
        Future<Integer> future2 = executorService.submit(new CC());

        //任务的数量和线程的数量一定一样吗

        //有个效果 -> 两个线程 - 同时执行这两个异步任务
        //pool - 1 - thread - 1 正在计算1 ~ 100
        //pool - 1 - thread - 2 正在计算1~ 10

        //需要将这两个线程执行的效果进行一个相加的操作

        try {
            //get()方法肯定是会等到线程执行完之后, 才会继续走
            Integer result1 = future1.get();
            Integer result2 = future2.get();

            //如果两个线程get()方法不走完, 那么main线程也是不会继续执行的
            System.out.println("开始整合....");
            int result = result1 + result2;

            //mian线程
            //5050 + 55 = 5150
            System.out.println(Thread.currentThread().getName() + ": " + result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        executorService.shutdown();
    }
}
class C2 implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"-正在计算1~100");
        int total = 0;
        for (int i = 1; i <= 100 ; i++) {
            total += i;
        }

        Thread.sleep(2000);
        return total;
    }
}

class CC implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"正在计算1~10");
        int total = 0;
        for (int i = 1; i <=10; i++) {
            total+=i;
        }
        Thread.sleep(2000);
        return total;
    }
}